package com.rds.system.service.impl;

import com.rds.common.exception.CustomException;
import com.rds.common.utils.DateUtils;
import com.rds.common.utils.SecurityUtils;
import com.rds.common.utils.StringUtils;
import com.rds.common.utils.uuid.SnowFlakeUtils;
import com.rds.system.domain.RdaNameCode;
import com.rds.system.mapper.RdaNameCodeMapper;
import com.rds.system.mapper.RdaTypeMapper;
import com.rds.system.service.IRdaNameCodeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.List;

/**
 * 编码器Service业务层处理
 * @author rds
 * @date 2021-10-12
 */
@Service
public class RdaNameCodeServiceImpl implements IRdaNameCodeService
{
    @Autowired
    private RdaNameCodeMapper rdaNamecodeMapper;

    @Autowired
    private RdaTypeMapper typeMapper;

    /**
     * 查询编码器
     * @param codeId 编码器ID
     * @return 编码器
     */
    @Override
    public RdaNameCode selectRdaNamecodeById(Long codeId)
    {
        return rdaNamecodeMapper.selectRdaNamecodeById(codeId);
    }

    /**
     * 查询编码器列表
     * @param rdaNamecode 编码器
     * @return 编码器
     */
    @Override
    public List<RdaNameCode> selectRdaNamecodeList(RdaNameCode rdaNamecode)
    {
        return rdaNamecodeMapper.selectRdaNamecodeList(rdaNamecode);
    }

    /**
     * 新增编码器
     * @param rdaNamecode 编码器
     * @return 结果
     */
    @Override
    public int insertRdaNamecode(RdaNameCode rdaNamecode) {
        String prefix = rdaNamecode.getCodePrefix();
        String suffix = rdaNamecode.getCodeSuffix();
        //如果编码前缀没有加入短横线 默认加入 并且前缀默认大写
        //2021-11-1 先去掉连接符号
        //prefix = prefix.indexOf("-") > -1 ? prefix.toUpperCase() : prefix.concat("-").toUpperCase() ;
        prefix = prefix.toUpperCase();
        //2021-11-03 如果前缀填写的是时间格式，需要装换成当前时间格式的时间作为前缀
        if("yyyyMMdd".equalsIgnoreCase(prefix) || "yyyyMM".equalsIgnoreCase(prefix) || "yyyy".equalsIgnoreCase(prefix)){
            prefix = DateUtils.parseDateToStr(prefix,new Date());
        }
        System.out.println("--->>>prefix:"+prefix);
        //默认后缀也是大写
        suffix = StringUtils.isBlank(suffix) ? suffix : suffix.toUpperCase();

        //检查当前前缀的编码是否存在
        RdaNameCode rdaNameCode2 = rdaNamecodeMapper.selectRdaNameCode(prefix);
        if(StringUtils.isNull(rdaNameCode2)){
            String currentValue = rdaNamecode.getCurrentValue();
            int numLength = rdaNamecode.getCodeNumberLength();
            System.out.println("--->>>currentValue:"+currentValue+"\tnumLength:"+numLength);
            int tempValue = Integer.valueOf(currentValue);
            currentValue = String.format("%0"+numLength+"d",tempValue);
            String nextValue = String.format("%0"+numLength+"d",(tempValue+1));

            rdaNamecode.setCodePrefix(prefix);
            rdaNamecode.setCodeSuffix(suffix);
            rdaNamecode.setCurrentValue(currentValue);
            rdaNamecode.setNextValue(nextValue);
            rdaNamecode.setOwnerid(SecurityUtils.getUserId());
        }else{
            throw new CustomException("含前缀"+prefix+"编码器已经存在,不允许创建重复编码器");
        }
        rdaNamecode.setId(SnowFlakeUtils.nextId());
        return rdaNamecodeMapper.insertRdaNamecode(rdaNamecode);
    }

    /**
     * 修改编码器
     *
     * @param rdaNamecode 编码器
     * @return 结果
     */
    @Override
    public int updateRdaNamecode(RdaNameCode rdaNamecode)
    {
        rdaNamecode.setUpdateTime(DateUtils.getNowDate());
        return rdaNamecodeMapper.updateRdaNamecode(rdaNamecode);
    }

    /**
     * 批量删除编码器
     *
     * @param codeIds 需要删除的编码器ID
     * @return 结果
     */
    @Override
    public int deleteRdaNamecodeByIds(Long[] codeIds)
    {
        return rdaNamecodeMapper.deleteRdaNamecodeByIds(codeIds);
    }

    /**
     * 删除编码器信息
     *
     * @param codeId 编码器ID
     * @return 结果
     */
    @Override
    public int deleteRdaNamecodeById(Long codeId)
    {
        return rdaNamecodeMapper.deleteRdaNamecodeById(codeId);
    }

    @Override
    public RdaNameCode selectRdaNameCode(String prefix) {
        return rdaNamecodeMapper.selectRdaNameCode(prefix);
    }

    /**
     * 根据当前类型自动生成编码号;如果是页面填写,则直接获取页面上传递的编码号
     * @param typeId 类型Id
     * @param code 编码(页面填写)
     * @return 新的编码或页面填写的编码
     */
    @Override
    public String getNewCodeNameNo(Long typeId,String code) {
        /**获取编码逻辑
         * 1.根据当前传递类型Id 查询当前类型是否管理编码管理器;如果有,直接使用当前编码管理器;如果没有,查询当前类型父类对象是否有管理编码管理器
         * 2.重复第一步操作,直至找到类型管理的编码管理器
         * 3.如果查询结束后还是没有找到类型管理的编码管理器 则提示信息
         * **/
        if(StringUtils.isBlank(code)){
            Long messageTypeId = typeId;
//            System.out.println("[CLASS]RdaNameCodeServiveImpl:getNewCodeNameNo[149]--->>typeId:"+typeId);
            RdaNameCode rdaNameCode = null;
            /**如果直接父类没有管理编码器,只要有父类就要一直往上查父类直至没有父类**/
            while(true){
                rdaNameCode = rdaNamecodeMapper.selectRdaNameCodeByTypeId(typeId);
                if(StringUtils.isNull(rdaNameCode)){
                    typeId = typeMapper.selectRdaTypeById(typeId).getParentid(); //获取当前类型的父类型Id
//                    System.out.println("[CLASS]RdaNameCodeServiveImpl:getNewCodeNameNo[156]--->>typeId:"+typeId);
                    if(typeId == 0L)break;
                }
                if(StringUtils.isNotNull(rdaNameCode))break;
            }
//            System.out.println("[CLASS]RdaNameCodeServiveImpl:getNewCodeNameNo[159]--->>rdaNameCode:"+rdaNameCode);
            if(StringUtils.isNull(rdaNameCode)){
                String typeDescription = typeMapper.selectRdaTypeById(messageTypeId).getDescription(); //打印当前传递类型的名称
                throw new CustomException("类型"+typeDescription+"没有关联编码器,请先定义编码器规则!");
            }

            //获取编码器的下一值作为值返回,将下一值作为当前值重新设置当前值的值并且重新计算下一值赋值下一值的属性值
            String prefix = rdaNameCode.getCodePrefix();
            String suffix = rdaNameCode.getCodeSuffix();
            suffix = StringUtils.isBlank(suffix) ? "" : suffix; //去除null

            //判断是否是首次使用编码(首次使用编码 当前值是1,多次使用当前值是会更改的)
            String currentValue = rdaNameCode.getCurrentValue();
            int numLength = rdaNameCode.getCodeNumberLength();
            String defaultCode = String.format("%0"+numLength+"d",1);//默认是1(首次进入)
            String newCode = defaultCode;

            if(!defaultCode.equals(currentValue)) { //如果当前值和默认值不一样 表示非首次进入
                newCode = rdaNameCode.getCurrentValue();
            }
            //更新数据库中的当前值和下一值
            String nextValue = rdaNameCode.getNextValue();
            String nextValue2 = String.format("%0"+numLength+"d",(Integer.valueOf(nextValue)+1));
            rdaNameCode.setCurrentValue(nextValue);
            rdaNameCode.setNextValue(nextValue2);
            rdaNamecodeMapper.updateRdaNamecode(rdaNameCode);

            StringBuilder newCodeBuilder = new StringBuilder(prefix);
            newCodeBuilder.append(newCode);
            newCodeBuilder.append(suffix);
            return newCodeBuilder.toString();
        }else{
            return code;
        }
    }
}
